/*************************************************
Ceebic
File name: // Ceebic_LCD.h
Author: // Fyman
Version: // 1.0
Date: // 完成日期
Description: //用于详细说明此程序文件完成的主要功能，与其他模块或函数的接口，输出值、取值范
围、含义及参数间的控制、顺序、独立或依赖等关系
Others: // 其它内容的说明
Function List: // 主要函数列表，每条记录应包括函数名及功能简要说明
1. ....
History: // 修改历史记录列表，每条修改记录应包括修改日期、修改者及修改内容简述
1. Date:
Author:
Modification:
2. ...
*************************************************/


/******************************************************************************/
/* Include files                                                              */
/******************************************************************************/
#include "ddl.h"
#include "i2c.h"
#include "rtc.h"
#include "gpio.h"
#include "uart.h"
/* C binding of definitions if building with C++ compiler */

/**
 ******************************************************************************
  **
 ******************************************************************************/
 
//@{

/******************************************************************************
 * Global definitions

*/
#include "cc_i2c.h"
#include "cc_lcd.h"
#include "cc_eeprom.h"
#include "ceebic_global.h"
#include "ceebic_extern.h"
#include "ceebic_calculate.h"


/*----------------------------------------------------------------------------*
**                             Mcaro Definitions                              *
**----------------------------------------------------------------------------*/


extern K0_T Kch[4];
extern Mbus_BUFFER_T Mbus_DATA;
extern struct_T meter_t;
extern unit_t mbus_unit;
extern uint8_t   u8LcdData[8] ;  //LCD显示数组
//extern uart_parameter_t uart_parameter;
//extern float32_t static_difference_time;
uint8_t pos=0xFF;      //安装位置标志位默认为0xFF

/*----------------------------------------------------------------------------*
**                             Global Vars                                    *
**----------------------------------------------------------------------------*/
COEF_SWITCH coef_add[4]=
{

		{
			ee_coef1_1,
			ee_coef1_2,
			ee_coef1_3,
			ee_coef1_4,	
			ee_coef1_5,
			
			ignore1_add,        //一声道始动量存储地址
      
			static_time1_add,   //一声道静止时间差存储地址
      
			pipeline1_add,      //一声道管道长度存储地址
			
			ee_flowpoint1_1,    //一声道第1流量点节点差存储地址
      ee_flowpoint1_2,    //一声道第2流量点节点差存储地址
      ee_flowpoint1_3,    //一声道第3流量点节点差存储地址
      ee_flowpoint1_4,    //一声道第4流量点节点差存储地址
      ee_flowpoint1_5     //一声道第5流量点节点差存储地址
		},
		
		{
			ee_coef2_1,
			ee_coef2_2,
			ee_coef2_3,
			ee_coef2_4,
			ee_coef2_5,
						
			ignore2_add,        //二声道始动量存储地址
														
			static_time2_add,   //二声道静止时间差存储地址
														
			pipeline2_add,      //二声道管道长度存储地址
														
			ee_flowpoint2_1,    //二声道第1流量点节点差存储地址
      ee_flowpoint2_2,    //二声道第2流量点节点差存储地址
      ee_flowpoint2_3,    //二声道第3流量点节点差存储地址
      ee_flowpoint2_4,    //二声道第4流量点节点差存储地址
      ee_flowpoint2_5     //二声道第5流量点节点差存储地址
		},
		
		{
			ee_coef3_1,
			ee_coef3_2,
			ee_coef3_3,
			ee_coef3_4,
			ee_coef3_5,
			
			ignore3_add,        //三声道始动量存储地址
														
			static_time3_add,   //三声道静止时间差存储地址
														
			pipeline3_add,      //三声道管道长度存储地址
														
			ee_flowpoint3_1,    //三声道第1流量点节点差存储地址
      ee_flowpoint3_2,    //三声道第2流量点节点差存储地址
      ee_flowpoint3_3,    //三声道第3流量点节点差存储地址
      ee_flowpoint3_4,    //三声道第4流量点节点差存储地址
      ee_flowpoint3_5     //三声道第5流量点节点差存储地址
		},
		
		{
			ee_coef4_1,
			ee_coef4_2,
			ee_coef4_3,
			ee_coef4_4,
			ee_coef4_5,
						
			ignore4_add,        //四声道始动量存储地址
														
			static_time4_add,   //四声道静止时间差存储地址
														
			pipeline4_add,      //四声道管道长度存储地址
														
			ee_flowpoint4_1,    //四声道第1流量点节点差存储地址
      ee_flowpoint4_2,    //四声道第2流量点节点差存储地址
      ee_flowpoint4_3,    //四声道第3流量点节点差存储地址
      ee_flowpoint4_4,    //四声道第4流量点节点差存储地址
      ee_flowpoint4_5     //四声道第5流量点节点差存储地址
		}
};


	month_basicadd_group monthly_sum_basic_add=
	{

		ee_month_heatdata_basic1,

		ee_month_heatunit_basic1	,

		ee_month_colddata_basic1	,

		ee_month_coldunit_basic1,
	};
/*-----------------------------------------------------------------------------
ee_month_flowdata_basicFunction Name	:	ceebic_eeprom_port_set
ee_month_flowunit_basicAuthor			:	OneMO
Created Time	:	2020.11.30
Description 	: 	eeprom页写入
Input Argv		:   
Output Argv 	:
Return Value	:   
-----------------------------------------------------------------------------*/

void ceebic_eeprom_port_init(void)

{
	
	stc_gpio_cfg_t stcGpioCfg;
    
    DDL_ZERO_STRUCT(stcGpioCfg);
    
    Sysctrl_SetPeripheralGate(SysctrlPeripheralGpio,TRUE);   //开启GPIO时钟门控 
    
    stcGpioCfg.enDir = GpioDirOut;                           ///< 端口方向配置->输出    
    stcGpioCfg.enOD = GpioOdEnable;                          ///< 开漏输出
    stcGpioCfg.enPu = GpioPuEnable;                          ///< 端口上拉配置->使能
    stcGpioCfg.enPd = GpioPdDisable;                         ///< 端口下拉配置->禁止
    stcGpioCfg.bOutputVal = TRUE;
    
    Gpio_Init(GpioPortD,GpioPin6,&stcGpioCfg);               ///< 端口初始化
    Gpio_Init(GpioPortD,GpioPin7,&stcGpioCfg);
    
    Gpio_SetAfMode(GpioPortD,GpioPin6,GpioAf1);              ///< 配置PD06为SCL
    Gpio_SetAfMode(GpioPortD,GpioPin7,GpioAf1);              ///< 配置PD07为SDA
}

void ceebic_eeprom_writeport_init(void)
 {   
    stc_gpio_cfg_t stcGpioCfg;
	 ///< 端口方向配置->输出(其它参数与以上（输入）配置参数一致)
    stcGpioCfg.enDir = GpioDirOut;
    ///< 端口上下拉配置->下拉
    stcGpioCfg.enPu = GpioPuDisable;
    stcGpioCfg.enPd = GpioPdEnable;
      
    ///< GPIO IO LED端口初始化
    Gpio_Init(GpioPortC,GpioPin13, &stcGpioCfg);
     
	 ///< 写保护关闭
	// Gpio_ClrIO(GpioPortC,GpioPin13);
}


	

   void cc_add_read(void)//热表地址读取函数 
	
	 {
	  
		 I2C_MasterReadData(M0P_I2C1,ee_add,Mbus_DATA.addr,7); //取出0x0000地址中的数据放置到Mbus_DATA结构体中的addr成员中
		
		 delay1ms(5);
	 }

	void cc_add_store(void)//热表地址存储函数 
	
	{

   //uint8_t addr[7]={0x22,0x11,0x11,0x11,0x11,0x11,0x22};
  
		I2C_MasterWriteData(M0P_I2C1,ee_add,Mbus_DATA.addr,7);//将Mbus_DATA中的addr数组中存储的地址数据存储到eeprom的0x0000地址中
    
		delay1ms(5);
			
	 //I2C_MasterWriteData(M0P_I2C1,ee_add,addr,7);         
   		
	 delay1ms(5);
	}
	
	
	
	void cc_sumflow_read(void)//累计流量读取函数
	{
 
		I2C_MasterReadData(M0P_I2C1,ee_sumflow,Mbus_DATA.sumflow_y,4); //取出0x0038地址中的数据放置到Mbus_DATA结构体中的sumflow_y成员（截至昨天24：00的累计数据）中
	    
		delay1ms(5);
	}
	
	void cc_sumflow_store(void)//累计流量存储函数
	{
	
		I2C_MasterWriteData(M0P_I2C1,ee_sumflow,Mbus_DATA.sumflow,4);//将Mbus_DATA中的sumflow数组中存储的地址数据存储到eeprom的对应地址中（每日24:00存储）
    
		delay1ms(5);
	}
	
	void cc_sumflow_unitchange_store(void)//累计流量存储函数(单位更改时)
	{
	
		I2C_MasterWriteData(M0P_I2C1,ee_sumflow,Mbus_DATA.sumflow_y,4);//将Mbus_DATA中的sumflow_y数组中存储的前一天24:00累计流量数据存储到eeprom的对应地址中(更改单位后重新存储)
    
		delay1ms(5);
	}



	void cc_sumheat_read(void)   //累计热量读取函数

	{
	//	uint8_t sumheat_unit=0;
		
		I2C_MasterReadData(M0P_I2C1,ee_sumheat,Mbus_DATA.sumheat_y,4);//取出0x0058地址中的数据放置到Mbus_DATA结构体中的sumheat_y成员中
		delay1ms(5);	

	}


	void cc_sumheat_store(void)  //累计热量存储函数，将数组中的累计热量存储至eeprom对应的地址中(一般每日24:00转存时调用)

	{
	  
	  
		I2C_MasterWriteData(M0P_I2C1,ee_sumheat,Mbus_DATA.sumheat,4);//将Mbus_DATA中的sumheat数组中存储的地址数据存储到eeprom的0x0058地址中(每日24:00自动存储)
		
		delay1ms(5);

	}


	void cc_sumheat_unitchange_store(void)  //累计热量存储函数，将数组中截止至昨天24:00的累计热量存储至eeprom对应的地址中（更改单位时使用）
		
	{
	  
		I2C_MasterWriteData(M0P_I2C1,ee_sumheat,Mbus_DATA.sumheat_y,4);//将Mbus_DATA中的sumheat数组中存储的地址数据存储到eeprom的0x0058地址中

		delay1ms(5);
	

	}
	
	
	void cc_sumcold_read(void)//累计冷量读取函数（此函数读取的冷量为上一天24:00时的累积量） 
	
	{
	  
		I2C_MasterReadData(M0P_I2C1,ee_sumcold   ,Mbus_DATA.sumcold_y,4);//取出0x0078地址中的数据放置到Mbus_DATA结构体中的sumcold_y成员中
		 
		delay1ms(5);
  	
	}
	
	
	
	void cc_sumcold_store(void)//累计冷量存储函数(每日24:00定时存储时调用)
	
	{

		
		I2C_MasterWriteData(M0P_I2C1,ee_sumcold,Mbus_DATA.sumcold,4);//将Mbus_DATA中的sumheat数组中存储的地址数据存储到eeprom的0x0078地址中
		
		delay1ms(5);

	
	}


	void cc_sumcold_unitchange_store(void)
		
	{
		
		I2C_MasterWriteData(M0P_I2C1,ee_sumcold,Mbus_DATA.sumcold_y,4);//将Mbus_DATA中的sumheat数组中存储的地址数据存储到eeprom的0x0078地址中
    
		delay1ms(5);

	}


	void cc_sum_read(void)//上电后运行，读取已保存的昨日24:00累积量数据至数组中
	{
		
		cc_sumheat_read();//累计热量读取函数（此函数读取的热量为上一天24:00时的累积量） 	
		cc_sumcold_read();//累计冷量读取函数（此函数读取的冷量为上一天24:00时的累积量） 
		cc_sumflow_read();//累计流量读取函数（此函数读取的流量为上一天24:00时的累积量） 
	}


	void cc_sum_unitchange_store(void)//更换单位时调用
	{
	 
		cc_sumheat_unitchange_store();//累计热量读取函数（此函数读取的热量为上一天24:00时的累积量） 	
		cc_sumcold_unitchange_store();//累计冷量读取函数（此函数读取的冷量为上一天24:00时的累积量） 
		cc_sumflow_unitchange_store();//累计流量读取函数（此函数读取的流量为上一天24:00时的累积量） 
	}


	void cc_sum_store(void)//每日24:00调用，存储累积量数据
	
	{		 

		cc_sumheat_store();//累计热量存储函数 	
		cc_sumcold_store();//累计冷量存储函数 
		cc_sumflow_store();//累计流量存储函数 
	}


	void cc_dailyheat_store(void)  //日累计热量存储函数，定时5min调用

	{
	
					
		I2C_MasterWriteData(M0P_I2C1,ee_dailyheat,Mbus_DATA.dayheat,4);     //将当日累计热量存储到eeprom对应地址中
    
		delay1ms(5);
		
	}


	void cc_dailycold_store(void)   //日累计冷量存储函数，定时5min调用
	{			
			
		I2C_MasterWriteData(M0P_I2C1,ee_dailycold,Mbus_DATA.dailycold,4);     //将当日累计热量存储到eeprom对应地址中
			
		delay1ms(5);
	}



	void cc_dailyflow_store(void)   //日累计流量存储函数，定时5min调用

	{

		I2C_MasterWriteData(M0P_I2C1,ee_dailyflow,Mbus_DATA.dailyflow,4);     //将当日累计热量存储到eeprom对应地址中

		delay1ms(5);

	}



	void cc_daliy_sum_store(void)           //每日累积量转存函数
	{
 
		cc_dailyheat_store();   //日累计热量存储函数

		cc_dailycold_store();   //日累计冷量存储函数
 
		cc_dailyflow_store();   //日累计流量存储函数
	}



	void cc_dailyheat_exactly_store(void)   //日累计热量存储函数
	{
		
		uint8_t c_dailyheat_unit;
	
			
		if(mbus_unit.sumheat_unit==KWH)
		{	
			c_dailyheat_unit=0x05;

		}		

		else if(mbus_unit.sumheat_unit==MWH)	
		{	
			c_dailyheat_unit=0x08;

		}			

		else if(mbus_unit.sumheat_unit==GJ)
		{
			c_dailyheat_unit=0x11;

		}
	
		I2C_MasterWriteData(M0P_I2C1,ee_dailyflow,Mbus_DATA.dayheat,4);     //将当日累计热量存储到eeprom对应地址中
  
		delay1ms(5);
		
		I2C_MasterWriteData(M0P_I2C1,ee_dailyflow_unit,&c_dailyheat_unit,1);  //将当日累计热量的单位存储到eeprom对应地址中
    
		delay1ms(5);

	}

	
	
	void cc_dailycold_exactly_store(void)   //日累计冷量实际存储函数，在每天结束时调用
	{
			
		boolean_t yearsign=currentyear;
		
		uint16_t cold_address;
				
		uint16_t cold_unit_address;
		
		stc_rtc_time_t readtime;
		
		uint8_t c_dailycold_unit;
		
		int add_point = 0 ;
		
		add_point = readtime.u8Month;
				
		cold_address = (add_point-1) * 0x100 + ee_day_colddata_basic ;
		
		cold_unit_address = (add_point-1) * 0x100 + ee_day_coldunit_basic;
		
		if(yearsign==lastyear)//若
		{	
			cold_address = (add_point-1) * 0x100 + ee_day_colddata_basic ;
		
			cold_unit_address = (add_point-1) * 0x100 + ee_day_coldunit_basic;
		}
		
		
		Rtc_ReadDateTime(&readtime);//配置RTC时间2019年4月17日10:01:55

			if(mbus_unit.sumheat_unit==KWH)
			{	
				c_dailycold_unit=0x05;

			}			

			else if(mbus_unit.sumheat_unit==MWH)	
			{	
				c_dailycold_unit=0x08;

			}				

			else if(mbus_unit.sumheat_unit==GJ)
			{
				c_dailycold_unit=0x11;

			}
							
			I2C_MasterWriteData(M0P_I2C1, ee_datadate_year_basic ,&readtime.u8Year,1);    //将当天年份存储到eeprom对应地址中
  
			delay1ms(5);
			
			I2C_MasterWriteData(M0P_I2C1,ee_datadate_month_basic,&readtime.u8Month,1);    //将当天月份存储到eeprom对应地址中
  
			delay1ms(5);
			
			I2C_MasterWriteData(M0P_I2C1,ee_datadate_day_basic,&readtime.u8Day,1);        //将当天日期存储到eeprom对应地址中
  
			delay1ms(5);
						
			I2C_MasterWriteData(M0P_I2C1,ee_day_heatdata_basic,Mbus_DATA.dailycold,4);    //将当天累计冷量存储到eeprom对应地址中
  
			delay1ms(5);
		
			I2C_MasterWriteData(M0P_I2C1,ee_day_heatdata_basic,&c_dailycold_unit,1);      //将当日累计冷量的单位存储到eeprom对应地址中
    
			delay1ms(5);

	} 


	void cc_dailyflow_exactly_store(void)   //日累计流量存储函数

	{
		uint8_t c_dailyflow_unit;
	
			
			if(mbus_unit.sumheat_unit==KWH)
			{	
				c_dailyflow_unit=0x05;

			}			

			else if(mbus_unit.sumheat_unit==MWH)	
			{	
				c_dailyflow_unit=0x08;

			}				

			else if(mbus_unit.sumheat_unit==GJ)
			{
				c_dailyflow_unit=0x11;

			}
	
			I2C_MasterWriteData(M0P_I2C1,ee_dailyflow,Mbus_DATA.dailycold,4);     //将当日累计热量存储到eeprom对应地址中
  
			delay1ms(5);
		
			I2C_MasterWriteData(M0P_I2C1,ee_dailyflow_unit,&c_dailyflow_unit,1);  //将当日累计热量的单位存储到eeprom对应地址中
    
			delay1ms(5);
	
	}	


void cc_daliy_sum_exactly_store(void)           //每日累积量转存函数
	
	{
		//将每天的累积量存储到对应日期的存储区域内
		cc_dailyheat_exactly_store();      //累计热量按日期存储函数 
		cc_dailycold_exactly_store();      //日累计冷量按日期存储函数
		cc_dailyflow_exactly_store();      //日累计流量按日期存储函数
	  
		cc_sumheat_store();//将累计热量存储至累计热量存储区域
		
		DDL_ZERO_STRUCT(Mbus_DATA.dayheat);  //清空日累计热量结构体;
		DDL_ZERO_STRUCT(Mbus_DATA.dailycold);//清空日累计冷量结构体
		DDL_ZERO_STRUCT(Mbus_DATA.dailyflow);//清空日累计流量结构体
		
		cumulativedischarge=0;               //累计流量变量清零，单位是立方米
    cumulativeheat=0;                    //累计热量，单位是kwh
    cumulativecold=0;                    //累计冷量，单位是kwh
	
	}
	
	void cc_daliy_sum_read(void)//上电后运行，读取已保存的每日累积量数据至数组中

	{

		cc_dailyflow_read();

		cc_dailycold_read();
 
		cc_dailyheat_read();

	}



	void cc_dailyflow_read(void)   //日累计热量读取函数
	{

		//uint8_t c_dailyflow_unit=0;

		I2C_MasterReadData(M0P_I2C1,ee_dailyflow,Mbus_DATA.dailyflow,4);
    delay1ms(5);

		cumulativedischarge=BCDTofloat2(Mbus_DATA.dailyflow);
	}


	void cc_dailycold_read(void)   //日累计冷量读取函数
	{

		//uint8_t c_dailycold_unit=0;		

		I2C_MasterReadData(M0P_I2C1,ee_dailyflow,Mbus_DATA.dailycold,4);
    delay1ms(5);

		cumulativecold=BCDTofloat2(Mbus_DATA.dailycold);
	}


	void cc_dailyheat_read(void)    //日累计流量读取函数
	{
		
		//uint8_t c_dailyheat_unit=0;
				
		I2C_MasterReadData(M0P_I2C1,ee_dailyflow,Mbus_DATA.dayheat,4);
    delay1ms(5);
		
		cumulativeheat=BCDTofloat2(Mbus_DATA.dayheat);
	}
	
	
	
	void cc_monthly_sum_store(void)
	{	

		uint8_t cunrrent_month_sum[4];
		float32_t lastmonthsum;
		float32_t cunrrentmonthsum;
		float32_t dailysum;

		{

			I2C_MasterReadData(M0P_I2C1,ee_monthly_flow,cunrrent_month_sum,4);

			lastmonthsum=BCDTofloat2(cunrrent_month_sum);

			dailysum=BCDTofloat2(Mbus_DATA.dailyflow);

			cunrrentmonthsum=lastmonthsum+dailysum;

			floatToBCD2(cunrrentmonthsum,cunrrent_month_sum);

			delay1ms(5);

			I2C_MasterWriteData(M0P_I2C1,ee_monthly_flow,cunrrent_month_sum,4);

			delay1ms(5);

		}
		
		{	
		
			I2C_MasterReadData(M0P_I2C1,ee_monthly_heat,cunrrent_month_sum,4);
		
			lastmonthsum=BCDTofloat2(cunrrent_month_sum);
		
			dailysum=BCDTofloat2(Mbus_DATA.dayheat);
		
			cunrrentmonthsum=lastmonthsum+dailysum;
		
			floatToBCD2(cunrrentmonthsum,cunrrent_month_sum);
		
			delay1ms(5);
	
			I2C_MasterWriteData(M0P_I2C1,ee_monthly_heat,cunrrent_month_sum,4);
		
			delay1ms(5);
		
		}
				
		{	
		
			I2C_MasterReadData(M0P_I2C1,ee_monthly_flow,cunrrent_month_sum,4);
		
			lastmonthsum=BCDTofloat2(cunrrent_month_sum);
		
			dailysum=BCDTofloat2(Mbus_DATA.dailyflow);
		
			cunrrentmonthsum=lastmonthsum+dailysum;
		
			floatToBCD2(cunrrentmonthsum,cunrrent_month_sum);
		
			delay1ms(5);
	
			I2C_MasterWriteData(M0P_I2C1,ee_monthly_cold,cunrrent_month_sum,4);
		
			delay1ms(5);
		
		}
		

	}
	
	
		void cc_monthly_sum_exactly_store(void)
	{	
 
		uint8_t c_monthlyflow_unit;
		uint8_t cunrrent_month_sum[4];
//  float32_t cunrrentmonthsum;
//	float32_t dailysum;

		{	
			I2C_MasterReadData(M0P_I2C1,ee_monthly_heat,cunrrent_month_sum,4);
		
			delay1ms(5);
	
			I2C_MasterWriteData(M0P_I2C1,ee_monthly_heat,cunrrent_month_sum,4);
		
			delay1ms(5);
		
	
			if(mbus_unit.sumheat_unit==KWH)
			{	
				c_monthlyflow_unit=0x05;

			}			

			else if(mbus_unit.sumheat_unit==MWH)	
			{	
				c_monthlyflow_unit=0x08;

			}				

			else if(mbus_unit.sumheat_unit==GJ)
			{
				c_monthlyflow_unit=0x11;

			}
	
			I2C_MasterWriteData(M0P_I2C1,ee_dailyflow_unit,&c_monthlyflow_unit,1);  //将当日累计热量的单位存储到eeprom对应地址中
			
			delay1ms(5);
		
		
		}
		
		
		{	
		
			I2C_MasterReadData(M0P_I2C1,ee_monthly_cold,cunrrent_month_sum,4);
		
			delay1ms(5);
	
			I2C_MasterWriteData(M0P_I2C1,ee_monthly_cold,cunrrent_month_sum,4);
		
			delay1ms(5);
		
	
			if(mbus_unit.sumheat_unit==KWH)
			{	
				c_monthlyflow_unit=0x05;

			}			

			else if(mbus_unit.sumheat_unit==MWH)	
			{	
				c_monthlyflow_unit=0x08;

			}				

			else if(mbus_unit.sumheat_unit==GJ)
			{
				c_monthlyflow_unit=0x11;

			}
	
			I2C_MasterWriteData(M0P_I2C1,ee_dailyflow_unit,&c_monthlyflow_unit,1);  //将当日累计热量的单位存储到eeprom对应地址中
			
			delay1ms(5);
		
		}
			
		
		
		{	
		
			I2C_MasterReadData(M0P_I2C1,ee_monthly_flow,cunrrent_month_sum,4);
		
			delay1ms(5);
	
			I2C_MasterWriteData(M0P_I2C1,ee_monthly_cold,cunrrent_month_sum,4);
		
			delay1ms(5);
		
	
//			if(mbus_unit.sumheat_unit==KWH)
//			{	
//				c_monthlyflow_unit=0x05;

//			}			

//			else if(mbus_unit.sumheat_unit==MWH)	
//			{	
//				c_monthlyflow_unit=0x08;

//			}				

//			else if(mbus_unit.sumheat_unit==GJ)
//			{
//				c_monthlyflow_unit=0x11;

//			}
//	
//		I2C_MasterWriteData(M0P_I2C1,ee_dailyflow_unit,&c_monthlyflow_unit,1);  //将当日累计热量的单位存储到eeprom对应地址中
			
			delay1ms(5);
		
		}
		

	}
	
	
	void cc_monthly_sum_read(uint8_t year,uint8_t month)
	{	
		
//		uint8_t c_sumheat_unit;
//		
//		if(mbus_unit.sumheat_unit==KWH)
//		{	
//			c_sumheat_unit=0x05;
//		}		
		I2C_MasterReadData(M0P_I2C1,ee_dailyflow,Mbus_sum_BUFF,4);
    
		delay1ms(5);
		
		I2C_MasterReadData(M0P_I2C1,ee_dailyheat,Mbus_sum_BUFF,4);
    
		delay1ms(5);
		
		I2C_MasterReadData(M0P_I2C1,ee_dailycold,Mbus_sum_BUFF,4);
	  
		delay1ms(5);
		
	}
	
	
	
	void cc_d_read(void)//热表口径读取函数
	
	{
		I2C_MasterReadData(M0P_I2C1,ee_calibre,Mbus_DATA.dn,2);//将Mbus_DATA中的calibre数组中存储的地址数据存储到eeprom的0x00F8地址中
		
		delay1ms(5); 
	}
		
	void cc_d_store(void)//热表口径读取函数
	
	{
		I2C_MasterWriteData(M0P_I2C1,ee_calibre,Mbus_DATA.dn,2);//将Mbus_DATA中的calibre数组中存储的地址数据存储到eeprom的0x00F8地址中
		
		delay1ms(5);
	}
	
	

	void cc_dist_read(void)
	{
		I2C_MasterReadData(M0P_I2C1,ee_dist,Mbus_DATA.dist,2);  //传感器距离读取函数 
		
		delay1ms(5);
	}
	
	void cc_dist_store(void)
	{
		I2C_MasterWriteData(M0P_I2C1,ee_dist,Mbus_DATA.dist,2); //传感器距离存储函数 
		
		delay1ms(5);
	}                                                      
	
	
	
	void cc_worktime_read(void)		
	{  
		I2C_MasterReadData(M0P_I2C1,ee_worktime,Mbus_DATA.worktime,3);//累计工作时间读取函数
		
		delay1ms(5);
	}
	
	void cc_worktime_store(void)		
	{  
		I2C_MasterWriteData(M0P_I2C1,ee_worktime,Mbus_DATA.worktime,3);//累计工作时间存储函数
		
		delay1ms(5);
	}
	
	
	
	
	void cc_position_read(void)//安装位置读取函数 
	{
		
		
		
		I2C_MasterReadData(M0P_I2C1,ee_pos,&pos,2);
		
		delay1ms(5);
	     
		if(pos==1)//如果安装在供水端
		{
			meter_t.install=FALSE;   //结构体元素置0
		}
	
		else if(pos==0)//如果安装在回水端
		{
			meter_t.install=TRUE;    //结构体元素置1
		}

	}
	
	
	
	void cc_position_store(void)//安装位置存储函数 
	{
     
		if(meter_t.install==FALSE)//如果安装在供水端
		{
		  pos=1;

			I2C_MasterWriteData(M0P_I2C1,ee_pos,&pos,2);		
			delay1ms(5);
		}
		else if(meter_t.install==TRUE)//如果安装在回水端
		{
			pos=0;
			
			I2C_MasterWriteData(M0P_I2C1,ee_pos,&pos,2);
			delay1ms(5);
		}
	}
	
	  
	void cc_sumheat_set(void)//每日24:00调用，读取累积量数据
	{		 
		float32_t	sumheat=0;
		
		I2C_MasterWriteData(M0P_I2C1,ee_sumheat,Mbus_DATA.sumheat,4);//将Mbus_DATA中的sumheat数组中存储的地址数据存储到eeprom的0x0078地址中
		
		delay1ms(5);
    		
		DDL_ZERO_STRUCT(Mbus_DATA.dayheat);//清空日累计流量结构体
		
		DDL_ZERO_STRUCT(Mbus_DATA.sumheat_y);//清空日累计流量结构体
		
		sumheat=BCDTofloat2(Mbus_DATA.sumheat);
		
		floatToBCD2(sumheat,Mbus_DATA.sumheat_y);

		cumulativeheat=0;                    //累计热量，单位是kwh
   // cc_daliy_sum_store();           //每日累积量转存函数
			cc_dailyheat_store();   //日累计热量存储函数

	}
	

  void cc_sumflow_set(void)//每日24:00调用，读取累积量数据
	
	{		 
		float32_t	sumflow=0;
		
		I2C_MasterWriteData(M0P_I2C1,ee_sumflow,Mbus_DATA.sumflow,4);//将Mbus_DATA中的sumheat数组中存储的地址数据存储到eeprom的0x0078地址中
		
		delay1ms(5);

		DDL_ZERO_STRUCT(Mbus_DATA.dailyflow);//清空日累计流量结构体
		
		DDL_ZERO_STRUCT(Mbus_DATA.sumflow_y);//清空日累计流量结构体
		
		sumflow=BCDTofloat2(Mbus_DATA.sumflow);
		
		floatToBCD2(sumflow,Mbus_DATA.sumflow_y);
		
		cumulativedischarge=0;               //累计流量变量清零，单位是立方米
		
		cc_dailyflow_store();   //日累计流量存储函数
		
	}
	
	
	
  void cc_sumcold_set(void)//每日24:00调用，读取累积量数据
	
	{		 
		float32_t	sumcold=0;
		
		I2C_MasterWriteData(M0P_I2C1,ee_sumcold,Mbus_DATA.sumcold,4);//将Mbus_DATA中的sumheat数组中存储的地址数据存储到eeprom的0x0078地址中
		
		delay1ms(5);
		
		DDL_ZERO_STRUCT(Mbus_DATA.dailycold);//清空日累计流量结构体
		
		DDL_ZERO_STRUCT(Mbus_DATA.sumcold_y);//清空日累计流量结构体
		
		sumcold=BCDTofloat2(Mbus_DATA.sumcold);
		
		floatToBCD2(sumcold,Mbus_DATA.sumcold_y);
		
		cumulativecold=0;                    //累计冷量，单位是kwh
			
		cc_dailycold_store();   //日累计冷量存储函数
 
	}
	
	
	
	void cc_serial_set_store(void)              //串口通讯参数存储函数

	{
    uint8_t check;

		uint8_t a =(Mbus_baud)>>8;
		
		uint8_t b =(Mbus_baud)&0xff;
		
		I2C_MasterWriteData(M0P_I2C1,ee_serial_baudrate_H,&a,1);//存储波特率变量的高位至对应的存储地址

		delay1ms(5);
				
		I2C_MasterWriteData(M0P_I2C1,ee_serial_baudrate_L,&b,1);//存储波特率变量的低位至对应的存储地址

		delay1ms(5);
		
		if(Mbus_check == UartMskDataOrAddr)
		{
		   check=0x01;
		}
      
		else if(Mbus_check == UartMskOdd)
		{
		   check=0x02;
		}
		
		else if(Mbus_check == UartMskEven)
		{
		   check=0x03;
		}
		
		I2C_MasterWriteData(M0P_I2C1,ee_serial_check,&check,1);//存储串口通讯的检验位设定至对应的存储地址
		delay1ms(5);
	}



	void cc_serial_set_read(void)               //串口通讯参数读取函数

	{
		uint8_t check;
    
		
		uint8_t c;
		
		uint8_t d;
		
		I2C_MasterReadData(M0P_I2C1,ee_serial_baudrate_H,&c,1);//将存储的波特率高8位放置到变量a中
		
		delay1ms(5);
		
		I2C_MasterReadData(M0P_I2C1,ee_serial_baudrate_L,&d,1);//将存储的波特率低8位放置到变量b中
		
		delay1ms(5);
	
		Mbus_baud=(c<<8|(d&=0xff));       //将储存的波特率读取至对应的结构体变量中
	
		I2C_MasterReadData(M0P_I2C1,ee_serial_check,&check,1);//将存储的串口通讯的检验位读取至对应的结构体变量中
    
		delay1ms(5);
		
		if(check==0x01)
		{
		   Mbus_check = UartMskDataOrAddr;
		}
      
		else if(check==0x02)
		{
		   
			Mbus_check = UartMskOdd;
		}
		
		else if(check==0x03)
		{
		
			Mbus_check = UartMskEven;
		}
		
		
	}
	
	
	
	void cc_unit_read(void)//单位设定读取函数 
	{
		
		I2C_MasterReadData(M0P_I2C1,ee_unit0,&kwandkwh,1);
		delay1ms(5);
		I2C_MasterReadData(M0P_I2C1,ee_unit1,&uint_mw ,1);
		delay1ms(5);
		I2C_MasterReadData(M0P_I2C1,ee_unit2,&uint_mwh,1);
		delay1ms(5);

	}
	
	void cc_unit_store(void)//单位设定存储函数 
	{
     
		I2C_MasterWriteData(M0P_I2C1,ee_unit0,&kwandkwh,1);
		delay1ms(5);
		I2C_MasterWriteData(M0P_I2C1,ee_unit1,&uint_mw ,1);
		delay1ms(5);
		I2C_MasterWriteData(M0P_I2C1,ee_unit2,&uint_mwh,1);
		delay1ms(5);
	}
	
	
	
	void cc_coef_store(int i)//声道系数存储函数，输入量为对应声道	
	
	{
		
    	
		I2C_MasterWriteData(M0P_I2C1,coef_add[i].coef_1         ,Mbus_DATA.Kch[i].Kx[0].K,4);//coef_add为对应声道系数在eeprom中的存储地址
		delay1ms(5);                                                                         //延时5ms
																				                                   
		I2C_MasterWriteData(M0P_I2C1,coef_add[i].coef_2         ,Mbus_DATA.Kch[i].Kx[1].K,4);//在初始地址偏移0xff的位置存储下一个流量点的系数
		delay1ms(5);                                                           
																					                                 
		I2C_MasterWriteData(M0P_I2C1,coef_add[i].coef_3         ,Mbus_DATA.Kch[i].Kx[2].K,4);//在初始地址偏移0xff的位置存储下一个流量点的系数
		delay1ms(5);                                                           
																					                                 
		I2C_MasterWriteData(M0P_I2C1,coef_add[i].coef_4         ,Mbus_DATA.Kch[i].Kx[3].K,4);//在初始地址偏移0xff的位置存储下一个流量点的系数
		delay1ms(5);                                                           
																					                                 
		I2C_MasterWriteData(M0P_I2C1,coef_add[i].coef_5         ,Mbus_DATA.Kch[i].Kx[4].K,4);//在初始地址偏移0xff的位置存储下一个流量点的系数
		delay1ms(5);													                                  
																					                                 
	  I2C_MasterWriteData(M0P_I2C1,coef_add[i].ignore_add     ,Mbus_DATA.Kch[i].ignore      ,2); //在对应地址的位置存储此声道的始动量
		delay1ms(5);                                                           
																					                                 
		I2C_MasterWriteData(M0P_I2C1,coef_add[i].static_time_add,Mbus_DATA.Kch[i].static_time ,2); //在初始地址偏移0xff的位置存储此声道的静态时间差
    delay1ms(5);                                                           
																				                                   
		I2C_MasterWriteData(M0P_I2C1,coef_add[i].pipeline_add   ,Mbus_DATA.Kch[i].pipeline_len,4); //在初始地址偏移0xff的位置存储此声道的管道长度
    delay1ms(5);											                                      
																					                                 
		I2C_MasterWriteData(M0P_I2C1,coef_add[i].ee_flowpoint_1 ,Mbus_DATA.Kch[i].K_node[0].K,4);//coef_add为对应声道系数在eeprom中的存储地址
    delay1ms(5);                                                             
																																							 
		I2C_MasterWriteData(M0P_I2C1,coef_add[i].ee_flowpoint_2 ,Mbus_DATA.Kch[i].K_node[1].K,4);//在初始地址偏移0xff的位置存储下一个流量点的时间差节点
    delay1ms(5);                                                            
																																					 	
 		I2C_MasterWriteData(M0P_I2C1,coef_add[i].ee_flowpoint_3 ,Mbus_DATA.Kch[i].K_node[2].K,4);//在初始地址偏移0xff的位置存储下一个流量点的时间差节点
  	delay1ms(5);                                                            
																																					 	
  	I2C_MasterWriteData(M0P_I2C1,coef_add[i].ee_flowpoint_4 ,Mbus_DATA.Kch[i].K_node[3].K,4);//在初始地址偏移0xff的位置存储下一个流量点的时间差节点
  	delay1ms(5);                                                            
																																					 	
  	I2C_MasterWriteData(M0P_I2C1,coef_add[i].ee_flowpoint_5 ,Mbus_DATA.Kch[i].K_node[4].K,4);//在初始地址偏移0xff的位置存储下一个流量点的时间差节点
  	delay1ms(5);	
	}
	
	
	
	void cc_coef_read(int i)  //声道系数读取函数，输入量为对应声道，

	{
 
		I2C_MasterReadData(M0P_I2C1,coef_add[i].coef_1         ,Mbus_DATA.Kch[i].Kx[0].K,4);//coef_add[i]为i声道系数在eeprom中的存储地址
		delay1ms(5);                                                           
		                                                                      
		I2C_MasterReadData(M0P_I2C1,coef_add[i].coef_2         ,Mbus_DATA.Kch[i].Kx[1].K,4);//在初始地址偏移0xff的位置存储下一个流量点的系数
		delay1ms(5);                                                          
		                                                                      
		I2C_MasterReadData(M0P_I2C1,coef_add[i].coef_3         ,Mbus_DATA.Kch[i].Kx[2].K,4);//在初始地址偏移0xff的位置存储下一个流量点的系数
		delay1ms(5);                                                          
		                                                                      
		I2C_MasterReadData(M0P_I2C1,coef_add[i].coef_4         ,Mbus_DATA.Kch[i].Kx[3].K,4);//在初始地址偏移0xff的位置存储下一个流量点的系数
		delay1ms(5);                                                          
		                                                                      
		I2C_MasterReadData(M0P_I2C1,coef_add[i].coef_5         ,Mbus_DATA.Kch[i].Kx[4].K,4);//在初始地址偏移0xff的位置存储下一个流量点的系数
    delay1ms(5);									                                         
		                                                                      
		I2C_MasterReadData(M0P_I2C1,coef_add[i].ignore_add     ,Mbus_DATA.Kch[i].ignore      ,2);//在初始地址偏移0xff的位置存储此声道的始动量
		delay1ms(5);                                                          
                                                                          
		I2C_MasterReadData(M0P_I2C1,coef_add[i].static_time_add,Mbus_DATA.Kch[i].static_time ,2);//在初始地址偏移0xff的位置存储此声道的静态时间差
		delay1ms(5);                                                          
		                                                                      
		I2C_MasterReadData(M0P_I2C1,coef_add[i].pipeline_add   ,Mbus_DATA.Kch[i].pipeline_len,4);//在初始地址偏移0xff的位置存储此声道的管道长度
    delay1ms(5);									                                         
		                                                                      
		I2C_MasterReadData(M0P_I2C1,coef_add[i].ee_flowpoint_1 ,Mbus_DATA.Kch[i].K_node[0].K,4);//coef_add为对应声道系数在eeprom中的存储地址
		delay1ms(5);                                                           
		                                     	                                	
		I2C_MasterReadData(M0P_I2C1,coef_add[i].ee_flowpoint_2 ,Mbus_DATA.Kch[i].K_node[1].K,4);//在初始地址偏移0xff的位置存储下一个流量点的时间差节点
		delay1ms(5);                                                           
		                                     	                                	
		I2C_MasterReadData(M0P_I2C1,coef_add[i].ee_flowpoint_3 ,Mbus_DATA.Kch[i].K_node[2].K,4);//在初始地址偏移0xff的位置存储下一个流量点的时间差节点
    delay1ms(5);                                                            
																																							
		I2C_MasterReadData(M0P_I2C1,coef_add[i].ee_flowpoint_4 ,Mbus_DATA.Kch[i].K_node[3].K,4);//在初始地址偏移0xff的位置存储下一个流量点的时间差节点
    delay1ms(5);                                                             
																																							 
		I2C_MasterReadData(M0P_I2C1,coef_add[i].ee_flowpoint_5 ,Mbus_DATA.Kch[i].K_node[4].K,4);//在初始地址偏移0xff的位置存储下一个流量点的时间差节点
    delay1ms(5);
	
	}
  
	
	
	void cc_time_read(void)//从eeprom中读取出时间数据并设置RTC
	{
		   
		stc_rtc_time_t settime;
	
		
		I2C_MasterReadData(M0P_I2C1,ee_time_year,&(settime.u8Year),1);    //从年存储地址读取存储的年份
    delay1ms(5);									                                                     
																																											 
		I2C_MasterReadData(M0P_I2C1,ee_time_month,&(settime.u8Month),1);  //从月存储地址读取存储的月份
    delay1ms(5);	                                                                                     
																																																				
		I2C_MasterReadData(M0P_I2C1,ee_time_day,&(settime.u8Day),1);      //从日存储地址读取存储的日期
    delay1ms(5);	                                                                                     
																																																				
		I2C_MasterReadData(M0P_I2C1,ee_time_hour,&(settime.u8Hour),1);    //从小时存储地址读取存储的小时数
    delay1ms(5);	                                                                                      
																																																				
		I2C_MasterReadData(M0P_I2C1,ee_time_minute,&(settime.u8Minute),1);//从分钟存储地址读取存储的分钟数
    delay1ms(5);	                                                                                     
																																																				
		I2C_MasterReadData(M0P_I2C1,ee_time_second,&(settime.u8Second),1);//从秒存储地址读取存储的秒数
    delay1ms(5);	
		    
		Rtc_SetTime(&settime);
	
	}

	void cc_time_store(void)//从RTC中读取出时间并存储

	{   
		stc_rtc_time_t readtime;
		
		Rtc_ReadDateTime(&readtime);
	
		I2C_MasterWriteData(M0P_I2C1,ee_time_year,&(readtime.u8Year),1);     //在年存储地址存储当前的年份
    delay1ms(5);									                                        
																																					
		I2C_MasterWriteData(M0P_I2C1,ee_time_month,&(readtime.u8Month),1);   //在月存储地址存储当前的月份
    delay1ms(5);	                                                        
																																					
		I2C_MasterWriteData(M0P_I2C1,ee_time_day,&(readtime.u8Day),1);       //在日存储地址存储当前的日期
    delay1ms(5);	                                                        
																																					
		I2C_MasterWriteData(M0P_I2C1,ee_time_hour,&(readtime.u8Hour),1);     //在小时存储地址存储当前的小时数
    delay1ms(5);	                                                        
																																					
		I2C_MasterWriteData(M0P_I2C1,ee_time_minute,&(readtime.u8Minute),1); //在分钟存储地址存储当前的分钟数
    delay1ms(5);	                                                        
																																					
		I2C_MasterWriteData(M0P_I2C1,ee_time_second,&(readtime.u8Second),1); //在秒存储地址存储当前的秒数
    delay1ms(5);	

	}//仪表时间存储函数






	void cc_daily_sum_store (void)
	{

		;

	}   //定时在每天24:00将日累计量存储地址中的数据转存至对应天的存储地址，并将总量加至总累积量与当前月累积量中并分别存储到总累计量与当前月累积量地址中

      //定时在每月最后一天将当前月累计量存储地址中的数据转存至对应月的存储地址

	void cc_read(void)

	{
   
		float32_t a,b,c;
		float32_t d,e,f;
		
		
		cc_position_read ();//读安装位置存储信息
		//pos=0xFF;
		if((pos!=0x01)&(pos!=0))       //若为初次上电
		{
		  meter_t.install=FALSE;   //更改安装标志位为供水安装
		 
			pos=1;                   //标志位置1
		
			cc_store();              //存储初始值至EEPROM
		
		}
		cc_add_read ();
		cc_sum_read();
		cc_daliy_sum_read();	
		cc_unit_read();
		cc_d_read();
		cc_dist_read();
		cc_time_read();
		cc_worktime_read ();
		
		a=BCDTofloat2(Mbus_DATA.sumflow_y);
		b=BCDTofloat2(Mbus_DATA.sumheat_y);
		c=BCDTofloat2(Mbus_DATA.sumcold_y);
  
		d = cumulativedischarge + a;
		e = cumulativeheat + b;   
		f = cumulativecold + c;    
		
		floatToBCD2(d,Mbus_DATA.sumflow);
		floatToBCD2(e,Mbus_DATA.sumheat);
		floatToBCD2(f,Mbus_DATA.sumcold);
    
		cc_coef_read(0);
		
		coefficient_1 = BCDTofloat2(Mbus_DATA.Kch[0].Kx[0].K);
		coefficient_2 = BCDTofloat2(Mbus_DATA.Kch[0].Kx[1].K);
		coefficient_3 = BCDTofloat2(Mbus_DATA.Kch[0].Kx[2].K);
		coefficient_4 = BCDTofloat2(Mbus_DATA.Kch[0].Kx[3].K);
		coefficient_5 = BCDTofloat2(Mbus_DATA.Kch[0].Kx[4].K);
		initialmomentum = BCDTofloat22(Mbus_DATA.Kch[0].ignore);
		static_difference_time=BCDTofloat22(Mbus_DATA.Kch[0].static_time);
		difference_time_1=BCDTofloat3(Mbus_DATA.Kch[0].K_node[0].K);
	  difference_time_2=BCDTofloat3(Mbus_DATA.Kch[0].K_node[1].K);
		difference_time_3=BCDTofloat3(Mbus_DATA.Kch[0].K_node[2].K);
		difference_time_4=BCDTofloat3(Mbus_DATA.Kch[0].K_node[3].K);
		difference_time_5=BCDTofloat3(Mbus_DATA.Kch[0].K_node[4].K);
	
	   cc_serial_set_read();   //串口通讯参数读取函数
	} 



	void cc_store(void)

	{

		cc_add_store();
    cc_sum_unitchange_store();
		cc_daliy_sum_store();	
	  cc_unit_store();
	  cc_position_store ();
    cc_d_store();
		cc_time_store();
		cc_dist_store();
	  cc_worktime_store (); 
	  cc_coef_store(1);	
    
		
		cc_serial_set_store();   //串口通讯参数存储函数
	} 



	void cc_incheck_store(void)//进检定数据存储函数

	{

		cc_daliy_sum_store();	

		DDL_ZERO_STRUCT( Mbus_DATA.sumheat );  //清空总累计热量结构体;
		DDL_ZERO_STRUCT(Mbus_DATA.sumheat_y);  //清空截至昨日累计热量结构体;
		DDL_ZERO_STRUCT( Mbus_DATA.sumflow );  //清空累计流量结构体;
		DDL_ZERO_STRUCT(Mbus_DATA.sumflow_y);  //清空截至昨日累计流量结构体;
		DDL_ZERO_STRUCT( Mbus_DATA.sumcold );  //清空累计冷量结构体;
		DDL_ZERO_STRUCT(Mbus_DATA.sumcold_y);  //清空截至昨日累计冷量结构体;

	  cumulativedischarge=0;//日累计流量
    cumulativeheat=0     ;//日累计热量
    cumulativecold=0     ;//日累计冷量

	}


	void cc_outcheck_read(void)  //出检定存储数据读取函数

	{

		cc_daliy_sum_read();	

	}


	void timing_store(void)//定时存储函数

	{

		cc_daliy_sum_store();	
	  cc_worktime_store(); 
	 // cc_coef_store(1);	

	}

